package com.cskaoyan.service;

import com.cskaoyan.bean.entity.*;
import com.cskaoyan.bean.vo.StatGoodsVo;
import com.cskaoyan.bean.vo.StatOrderVo;
import com.cskaoyan.bean.vo.StatUserVo;
import com.cskaoyan.mapper.OrderGoodsMapper;
import com.cskaoyan.mapper.OrderMapper;
import com.cskaoyan.mapper.UserMapper;
import com.cskaoyan.utils.StartAndEndTimeUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.*;

/**
 * @program: project2_market
 * @time: 2021/10/19
 * @author: yangshuai
 **/

@Service
public class StatServiceImpl implements StatService{

    @Autowired
    UserMapper userMapper;
    @Autowired
    OrderMapper orderMapper;
    @Autowired
    OrderGoodsMapper orderGoodsMapper;

    /**
     * 统计用户
     * @return
     */
    @Override
    public StatUserVo selectUser() {

        // 查询用户表，用户注册时间，统计当天人数
        // 设置条件
        UserExample example = new UserExample();
        UserExample.Criteria criteria = example.createCriteria();
        criteria.andAddTimeIsNotNull();
        example.setOrderByClause("add_time");

        // 查询用户表，注册时间不为空的数据
        List<User> users = userMapper.selectByExample(example);

        // 添加要返回的列名
        List<String> columns = new ArrayList<>();
        columns.add(0,"day");
        columns.add(1,"users");

        // 添加返回的每一行数据
        List<StatUserVo.Rows> rows = new ArrayList<>();
        // 保存订单表所有不重复时间
        ArrayList<Date> dates = new ArrayList<>();
        // 临时数组，去除重复时间
        ArrayList<Date> arr = new ArrayList<>();

        Date addTime = null;   // 查询到的用户注册时间
        String temp = null;  // 保存上一个用户注册时间，用来比较注册时间是否相同
        Date startTime = null;  // 一天的开始时间
        Date endTime = null;    // 一天的结束时间
        int index = 0;
        for (User user : users) {

            // 获取所有的不重复时间
            //转换格式
            Date date = new StartAndEndTimeUtils().starTime(user.getAddTime());

            // 添加到数组
            arr.add(index,date);

            // 添加到数组
            if (!dates.contains(arr.get(index))){
                dates.add(arr.get(index));
            }

        }

        int i = 0;
        for (Date date : dates) {
            // 数据库用户表的注册时间
            addTime = date;
            StartAndEndTimeUtils startAndEndTimeUtils = new StartAndEndTimeUtils();
            List<Date> dateList = startAndEndTimeUtils.startAndEndTime(addTime);
            // 获取开始和结束时间，不取出年月日
//            List<Date> dateList = startAndEndTimeUtils.getTwoDates(addTime);
            Date start = dateList.get(0);   // 一天的开始时间
            Date end = dateList.get(1);     // 一天的结束时间

            // 查询一天注册的用户
            UserExample userExample = new UserExample();
            UserExample.Criteria criteria1 = userExample.createCriteria();
            criteria1.andAddTimeBetween(start,end);     // 查询条件Between
//            userExample.setDistinct(true);  // 使用去重
            Integer countUsers = Math.toIntExact(userMapper.countByExample(userExample));

            StatUserVo.Rows row = new StatUserVo.Rows(date, countUsers);

            rows.add(i,row);
            i++;
        }
        // 要返回的对象StatUserVo
        return new StatUserVo(columns,rows);
    }


    /**
     * 订单统计
     * @return
     */
    @Override
    public StatOrderVo selectOrder() {

        List<StatOrderVo.Rows> rows = new ArrayList<>();
        StatOrderVo.Rows row = null;

        // 添加要返回的列名
        List<String> columns = new ArrayList<>();
        columns.add(0,"day");
        columns.add(1,"orders");
        columns.add(2,"customers");
        columns.add(3,"amount");
        columns.add(4,"pcr");

        // 设置条件，取出
        OrderExample example = new OrderExample();
        OrderExample.Criteria criteria = example.createCriteria();
        criteria.andIdIsNotNull();
        example.setOrderByClause("add_time");

        // 获取所有订单
        List<Order> orders = orderMapper.selectByExample(example);

        // 保存订单表所有不重复时间
        ArrayList<Date> dates = new ArrayList<>();
        // 临时数组，去除重复时间
        ArrayList<Date> arr = new ArrayList<>();
//         通过订单创建时间，查询订单量，下单用户数量，订单总额
        int index = 0;
        for (Order order : orders) {

            // 取出年月日
            StartAndEndTimeUtils startAndEndTimeUtils = new StartAndEndTimeUtils();
            Date date = startAndEndTimeUtils.starTime(order.getAddTime());
            // 临时数组
            arr.add(date);
            // 添加到目标数组
            if (!dates.contains(date)) {
                dates.add(date);
            }
        }

        for (Date date : dates) {

            // 获取一天的开始和结束时间
            StartAndEndTimeUtils startAndEndTimeUtils = new StartAndEndTimeUtils();
            List<Date> dateList = startAndEndTimeUtils.startAndEndTime(date);
            // 获取开始和结束时间，不取出年月日
//            List<Date> twoDates = startAndEndTimeUtils.getTwoDates(date);
            Date start = dateList.get(0);
            Date end = dateList.get(1);

            OrderExample orderExample = new OrderExample();
            OrderExample.Criteria criteria1 = orderExample.createCriteria();
            criteria1.andAddTimeBetween(start,end);
            List<Order> orderList = orderMapper.selectByExample(orderExample);

            // 当天订单数量
            Integer countOrders = orderList.size();
            // 当日订单总金额
            Double amount = 0.0;

            // 下单用户数量,去重后的
            ArrayList<Integer> list = new ArrayList<>();

            // 每天的订单
            for (int i = 0; i < orderList.size(); i++) {
                // 下单用户数量
                Integer userId = orderList.get(i).getUserId();
                if (!list.contains(userId)){
                    list.add(userId);
                }

                // 当日订单总金额
                BigDecimal orderPrice = orderList.get(i).getOrderPrice();
                Double orderPrice1 = orderPrice.doubleValue();   // 转为double
                amount += orderPrice1;

            }
            // 下单用户数量
            Integer countUsers = list.size();
            // 客单价
            Double pcr = amount / countUsers;

            row = new StatOrderVo.Rows(amount,countOrders,countUsers,date,pcr);
            rows.add(row);

        }

        return new StatOrderVo(columns,rows);
    }

    /**
     * 商品统计
     * @return
     */

    @Override
    public StatGoodsVo selectGoods() {
        // 要返回的rows表
        List<StatGoodsVo.Rows> rows = new ArrayList<>();
        StatGoodsVo.Rows row = null;

        // 添加列名列表
        List<String> columns = new ArrayList<>();
        columns.add(0,"day");
        columns.add(1,"orders");
        columns.add(2,"products");
        columns.add(3,"amount");

        // 查询所有订单
        OrderExample example = new OrderExample();
        OrderExample.Criteria criteria = example.createCriteria();
        criteria.andIdIsNotNull();
        example.setOrderByClause("add_time");

        // 获取所有订单
        List<Order> orders = orderMapper.selectByExample(example);

        // 保存订单表的所有不重复时间
        ArrayList<Date> dates = new ArrayList<>();
        // 临时数组，去除重复时间
        ArrayList<Date> arr = new ArrayList<>();
//         通过订单创建时间，查询订单量，下单用户数量，订单总额
        int index = 0;
        for (Order order : orders) {

            // 取出年月日
            StartAndEndTimeUtils startAndEndTimeUtils = new StartAndEndTimeUtils();
            Date date = startAndEndTimeUtils.starTime(order.getAddTime());
            // 临时数组
//            arr.add(date);
            // 添加到目标数组
            if (!dates.contains(date)) {
                dates.add(date);
            }
        }

        for (Date date : dates) {

            // 获取一天的开始和结束时间
            StartAndEndTimeUtils startAndEndTimeUtils = new StartAndEndTimeUtils();
            List<Date> dateList = startAndEndTimeUtils.startAndEndTime(date);
            // 获取开始和结束时间，不取出年月日
//            List<Date> dateList = startAndEndTimeUtils.getTwoDates(date);
            Date start = dateList.get(0);
            Date end = dateList.get(1);

            OrderExample orderExample = new OrderExample();
            OrderExample.Criteria criteria1 = orderExample.createCriteria();
            criteria1.andAddTimeBetween(start,end);
            List<Order> orderList = orderMapper.selectByExample(orderExample);

//            // 获取一天的数据
//            OrderGoodsExample orderGoodsExample = new OrderGoodsExample();
//            OrderGoodsExample.Criteria criteria2 = orderGoodsExample.createCriteria();
//            criteria2.andAddTimeBetween(start,end);
//            List<OrderGoods> orderGoods = orderGoodsMapper.selectByExample(orderGoodsExample);
            // 获取一天的各个订单的下单货品数量的列表
            List<Integer> numbers = orderGoodsMapper.selectBetween(start, end);

            // 当天订单数量
            Integer countOrders = orderList.size();
            // 当日订单总金额
            Double amount = 0.0;

            // 订单表每天的订单
            for (int i = 0; i < orderList.size(); i++) {
                // 当日订单总金额
                BigDecimal orderPrice = orderList.get(i).getOrderPrice();
                Double orderPrice1 = orderPrice.doubleValue();   // 转为double
                amount += orderPrice1;
            }

            // 下单货品数量
            Integer number = 0;
            //商品订单关联表
//            for (OrderGoods orderGood : orderGoods) {
//                // 下单货品数量
//                number += Integer.valueOf(orderGood.getNumber());
//            }
            for (Integer num : numbers) {
                number += num;
            }

            // 新建返回对象StatGoodsVo.Rows，添加数据
//            row = new StatGoodsVo.Rows(amount,countOrders,date,number);
            row = new StatGoodsVo.Rows(amount,countOrders,start,number);
            rows.add(row);

        }

        StatGoodsVo statGoodsVo = new StatGoodsVo(columns, rows);
        String s = statGoodsVo.toString();
        return statGoodsVo;
    }

}
